package timing.jframe4l.common.file;

import java.awt.AlphaComposite;  
import java.awt.Color;  
import java.awt.Font;  
import java.awt.Graphics;  
import java.awt.Graphics2D;  
import java.awt.Point;  
import java.awt.Rectangle;  
import java.awt.color.ColorSpace;  
import java.awt.image.BufferedImage;  
import java.awt.image.ColorConvertOp;  
import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.FileReader;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.Iterator;  
import java.util.List;  
  
import javax.imageio.ImageIO;  
import javax.imageio.ImageReadParam;  
import javax.imageio.ImageReader;  
import javax.imageio.stream.ImageInputStream;  
  
import com.sun.image.codec.jpeg.JPEGCodec;  
import com.sun.image.codec.jpeg.JPEGImageEncoder;  
  
public class ImageUtil{  
  
    public ImageUtil() {  
        super();  
    }  
  
    /**  
     * 对图片裁剪，并把裁剪新图片保存  
     * @param srcPath 读取源图片路径 
     * @param toPath    写入图片路径 
     * @param x 剪切起始点x坐标 
     * @param y 剪切起始点y坐标 
     * @param width 剪切宽度 
     * @param height     剪切高度 
     * @param readImageFormat  读取图片格式 
     * @param writeImageFormat 写入图片格式 
     * @throws IOException 
     */  
    public void cropImage(String srcPath,String toPath,  
            int x,int y,int width,int height,  
            String readImageFormat,String writeImageFormat) throws IOException{     
        FileInputStream fis = null ;  
        ImageInputStream iis =null ;  
        try{     
            //读取图片文件  
            fis = new FileInputStream(srcPath);   
            Iterator it = ImageIO.getImageReadersByFormatName(readImageFormat);   
            ImageReader reader = (ImageReader) it.next();   
            //获取图片流   
            iis = ImageIO.createImageInputStream(fis);    
            reader.setInput(iis,true) ;  
            ImageReadParam param = reader.getDefaultReadParam();   
            //定义一个矩形  
            Rectangle rect = new Rectangle(x, y, width, height);   
            //提供一个 BufferedImage，将其用作解码像素数据的目标。   
            param.setSourceRegion(rect);  
            BufferedImage bi = reader.read(0,param);                  
            //保存新图片   
            ImageIO.write(bi, writeImageFormat, new File(toPath));       
        }finally{  
            if(fis!=null)  
                fis.close();         
            if(iis!=null)  
               iis.close();   
        }   
    }  
  
    /** 
     * 按倍率缩小图片 
     * @param srcImagePath 读取图片路径 
     * @param toImagePath 写入图片路径 
     * @param widthRatio    宽度缩小比例 
     * @param heightRatio    高度缩小比例 
     * @throws IOException 
     */  
    public void reduceImageByRatio(String srcImagePath,String toImagePath,int widthRatio,int heightRatio) throws IOException{  
        FileOutputStream out = null;  
        try{  
            //读入文件    
            File file = new File(srcImagePath);    
            // 构造Image对象    
            BufferedImage src = ImageIO.read(file);
            int width = src.getWidth();    
            int height = src.getHeight();    
            // 缩小边长   
            BufferedImage tag = new BufferedImage(width / widthRatio, height / heightRatio, BufferedImage.TYPE_INT_RGB);    
            // 绘制 缩小  后的图片   
            tag.getGraphics().drawImage(src, 0, 0, width / widthRatio, height / heightRatio, null);    
            out = new FileOutputStream(toImagePath);    
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);    
            encoder.encode(tag);    
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(out != null){  
                out.close();    
            }  
        }  
    }  
  
    /** 
     * 长高等比例缩小图片 
     * @param srcImagePath 读取图片路径 
     * @param toImagePath 写入图片路径 
     * @param ratio 缩小比例 
     * @throws IOException 
     */  
    public void reduceImageEqualProportion(String srcImagePath,String toImagePath,int ratio) throws IOException{  
        FileOutputStream out = null;  
        try{  
            //读入文件    
            File file = new File(srcImagePath);    
            // 构造Image对象    
            BufferedImage src = ImageIO.read(file);
            int width = src.getWidth();    
            int height = src.getHeight();    
            // 缩小边长   
            BufferedImage tag = new BufferedImage(width / ratio, height / ratio, BufferedImage.TYPE_INT_RGB);    
            // 绘制 缩小  后的图片   
            tag.getGraphics().drawImage(src, 0, 0, width / ratio, height / ratio, null);    
            out = new FileOutputStream(toImagePath);    
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);    
            encoder.encode(tag);    
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(out != null){  
                out.close();    
            }  
        }  
    }  
      
    /** 
     * 按倍率放大图片 
     * @param srcImagePath 读取图形路径 
     * @param toImagePath 写入入行路径 
     * @param widthRatio    宽度放大比例 
     * @param heightRatio 高度放大比例 
     * @throws IOException 
     */  
    public void enlargementImageByRatio(String srcImagePath,String toImagePath,int widthRatio,int heightRatio) throws IOException{  
        FileOutputStream out = null;  
        try{  
            //读入文件    
            File file = new File(srcImagePath);    
            // 构造Image对象    
            BufferedImage src = ImageIO.read(file);
            int width = src.getWidth();    
            int height = src.getHeight();    
            // 放大边长  
            BufferedImage tag = new BufferedImage(width * widthRatio, height * heightRatio, BufferedImage.TYPE_INT_RGB);    
            //绘制放大后的图片  
            tag.getGraphics().drawImage(src, 0, 0, width * widthRatio, height * heightRatio, null);    
            out = new FileOutputStream(toImagePath);    
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);    
            encoder.encode(tag);    
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(out != null){  
                out.close();    
            }  
        }  
    }  
      
      
    /** 
     * 长高等比例放大图片 
     * @param srcImagePath 读取图形路径 
     * @param toImagePath 写入入行路径 
     * @param ratio 放大比例 
     * @throws IOException 
     */  
    public void enlargementImageEqualProportion(String srcImagePath,String toImagePath,int ratio) throws IOException{  
        FileOutputStream out = null;  
        try{  
            //读入文件    
            File file = new File(srcImagePath);    
            // 构造Image对象    
            BufferedImage src = ImageIO.read(file);
            int width = src.getWidth();    
            int height = src.getHeight();    
            // 放大边长  
            BufferedImage tag = new BufferedImage(width * ratio, height * ratio, BufferedImage.TYPE_INT_RGB);    
            //绘制放大后的图片  
            tag.getGraphics().drawImage(src, 0, 0, width * ratio, height * ratio, null);    
            out = new FileOutputStream(toImagePath);    
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);    
            encoder.encode(tag);    
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(out != null){  
                out.close();    
            }  
        }  
    }  
      
    /** 
     * 重置图形的边长大小 
     * @param srcImagePath  
     * @param toImagePath 
     * @param width 
     * @param height 
     * @throws IOException 
     */  
    public void resizeImage(String srcImagePath,String toImagePath,int width,int height) throws IOException{  
        FileOutputStream out = null;  
        try{  
            //读入文件    
            File file = new File(srcImagePath);    
            // 构造Image对象    
            BufferedImage src = ImageIO.read(file);
            // 放大边长  
            BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);    
            //绘制放大后的图片  
            tag.getGraphics().drawImage(src, 0, 0, width, height, null);    
            out = new FileOutputStream(toImagePath);    
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);    
            encoder.encode(tag);    
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(out != null){  
                out.close();    
            }  
        }  
    }  
      
    /** 
     * 横向拼接图片（两张） 
     * @param firstSrcImagePath 第一张图片的路径 
     * @param secondSrcImagePath    第二张图片的路径 
     * @param imageFormat   拼接生成图片的格式 
     * @param toPath    拼接生成图片的路径 
     */  
    public void joinImagesHorizontal(String firstSrcImagePath, String secondSrcImagePath,String imageFormat, String toPath){    
        try {    
            //读取第一张图片      
            File  fileOne  =  new  File(firstSrcImagePath);      
            BufferedImage  imageOne = ImageIO.read(fileOne);      
            int  width  =  imageOne.getWidth();//图片宽度      
            int  height  =  imageOne.getHeight();//图片高度      
            //从图片中读取RGB      
            int[]  imageArrayOne  =  new  int[width*height];      
            imageArrayOne  =  imageOne.getRGB(0,0,width,height,imageArrayOne,0,width);      
             
            //对第二张图片做相同的处理      
            File  fileTwo  =  new  File(secondSrcImagePath);      
            BufferedImage  imageTwo  =  ImageIO.read(fileTwo);   
            int width2 = imageTwo.getWidth();  
            int height2 = imageTwo.getHeight();  
            int[]   ImageArrayTwo  =  new  int[width2*height2];      
            ImageArrayTwo  =  imageTwo.getRGB(0,0,width,height,ImageArrayTwo,0,width);      
            //ImageArrayTwo  =  imageTwo.getRGB(0,0,width2,height2,ImageArrayTwo,0,width2);   
             
            //生成新图片  
            //int height3 = (height>height2 || height==height2)?height:height2;  
            BufferedImage  imageNew  =  new  BufferedImage(width*2,height,BufferedImage.TYPE_INT_RGB);      
            //BufferedImage  imageNew  =  new  BufferedImage(width+width2,height3,BufferedImage.TYPE_INT_RGB);      
            imageNew.setRGB(0,0,width,height,imageArrayOne,0,width);//设置左半部分的RGB    
            imageNew.setRGB(width,0,width,height,ImageArrayTwo,0,width);//设置右半部分的RGB   
            //imageNew.setRGB(width,0,width2,height2,ImageArrayTwo,0,width2);//设置右半部分的RGB      
             
            File  outFile  =  new  File(toPath);      
            ImageIO.write(imageNew,  imageFormat,  outFile);//写图片  
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
    }  
      
    /** 
     * 横向拼接一组（多张）图像 
     * @param pics  将要拼接的图像 
     * @param type 图像写入格式 
     * @param dst_pic 图像写入路径 
     * @return 
     */  
    public  boolean joinImageListHorizontal(String[] pics, String type, String dst_pic) {     
        try {    
            int len = pics.length;    
            if (len < 1) {    
                System.out.println("pics len < 1");    
                return false;    
            }    
            File[] src = new File[len];    
            BufferedImage[] images = new BufferedImage[len];    
            int[][] imageArrays = new int[len][];    
            for (int i = 0; i < len; i++) {    
                src[i] = new File(pics[i]);    
                images[i] = ImageIO.read(src[i]);    
                int width = images[i].getWidth();    
                int height = images[i].getHeight();    
                imageArrays[i] = new int[width * height];// 从图片中读取RGB      
                imageArrays[i] = images[i].getRGB(0, 0, width, height,  imageArrays[i], 0, width);    
            }    
              
            int dst_width = 0;    
            int dst_height = images[0].getHeight();    
            for (int i = 0; i < images.length; i++) {    
                dst_height = dst_height > images[i].getHeight() ? dst_height : images[i].getHeight();    
                dst_width += images[i].getWidth();  
            }    
            //System.out.println(dst_width);    
            //System.out.println(dst_height);    
            if (dst_height < 1) {    
                System.out.println("dst_height < 1");    
                return false;    
            }   
            /* 
             * 生成新图片 
             */     
            BufferedImage ImageNew = new BufferedImage(dst_width, dst_height,  BufferedImage.TYPE_INT_RGB);    
            int width_i = 0;  
            for (int i = 0; i < images.length; i++) {    
                ImageNew.setRGB(width_i, 0, images[i].getWidth(), dst_height,  imageArrays[i], 0, images[i].getWidth());    
                width_i += images[i].getWidth();  
            }    
            File outFile = new File(dst_pic);    
            ImageIO.write(ImageNew, type, outFile);// 写图片     
        } catch (Exception e) {    
            e.printStackTrace();    
            return false;    
        }    
        return true;    
    }  
      
    /** 
     * 纵向拼接图片（两张） 
     * @param firstSrcImagePath 读取的第一张图片 
     * @param secondSrcImagePath    读取的第二张图片 
     * @param imageFormat 图片写入格式 
     * @param toPath    图片写入路径 
     */  
    public void joinImagesVertical(String firstSrcImagePath, String secondSrcImagePath,String imageFormat, String toPath){    
        try {    
            //读取第一张图片      
            File  fileOne  =  new  File(firstSrcImagePath);      
            BufferedImage  imageOne = ImageIO.read(fileOne);      
            int  width  =  imageOne.getWidth();//图片宽度      
            int  height  =  imageOne.getHeight();//图片高度      
            //从图片中读取RGB      
            int[]  imageArrayOne  =  new  int[width*height];      
            imageArrayOne  =  imageOne.getRGB(0,0,width,height,imageArrayOne,0,width);      
         
            //对第二张图片做相同的处理      
            File  fileTwo  =  new  File(secondSrcImagePath);      
            BufferedImage  imageTwo  =  ImageIO.read(fileTwo);   
            int width2 = imageTwo.getWidth();  
            int height2 = imageTwo.getHeight();  
            int[]   ImageArrayTwo  =  new  int[width2*height2];      
            ImageArrayTwo  =  imageTwo.getRGB(0,0,width,height,ImageArrayTwo,0,width);      
            //ImageArrayTwo  =  imageTwo.getRGB(0,0,width2,height2,ImageArrayTwo,0,width2);   
         
            //生成新图片  
            //int width3 = (width>width2 || width==width2)?width:width2;  
            BufferedImage  imageNew  =  new  BufferedImage(width,height*2,BufferedImage.TYPE_INT_RGB);      
            //BufferedImage  imageNew  =  new  BufferedImage(width3,height+height2,BufferedImage.TYPE_INT_RGB);      
            imageNew.setRGB(0,0,width,height,imageArrayOne,0,width);//设置上半部分的RGB      
            imageNew.setRGB(0,height,width,height,ImageArrayTwo,0,width);//设置下半部分的RGB  
            //imageNew.setRGB(0,height,width2,height2,ImageArrayTwo,0,width2);//设置下半部分的RGB      
         
            File  outFile  =  new  File(toPath);      
            ImageIO.write(imageNew,  imageFormat,  outFile);//写图片  
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
    }  
      
    /** 
     * 纵向拼接一组（多张）图像 
     * @param pics      将要拼接的图像数组 
     * @param type  写入图像类型 
     * @param dst_pic   写入图像路径 
     * @return 
     */  
    public  boolean joinImageListVertical(String[] pics, String type, String dst_pic) {     
        try {    
            int len = pics.length;    
            if (len < 1) {    
                System.out.println("pics len < 1");    
                return false;    
            }    
             File[] src = new File[len];    
             BufferedImage[] images = new BufferedImage[len];    
             int[][] imageArrays = new int[len][];    
             for (int i = 0; i < len; i++) {    
                //System.out.println(i);  
                src[i] = new File(pics[i]);    
                images[i] = ImageIO.read(src[i]);    
                int width = images[i].getWidth();    
                int height = images[i].getHeight();    
                imageArrays[i] = new int[width * height];// 从图片中读取RGB     
                imageArrays[i] = images[i].getRGB(0, 0, width, height,  imageArrays[i], 0, width);    
            }    
               
            int dst_height = 0;    
            int dst_width = images[0].getWidth();    
            for (int i = 0; i < images.length; i++) {    
                dst_width = dst_width > images[i].getWidth() ? dst_width : images[i].getWidth();    
                dst_height += images[i].getHeight();    
            }    
            //System.out.println(dst_width);    
            //System.out.println(dst_height);    
            if (dst_height < 1) {    
                System.out.println("dst_height < 1");    
                return false;    
            }    
            /* 
             * 生成新图片 
             */     
            BufferedImage ImageNew = new BufferedImage(dst_width, dst_height,  BufferedImage.TYPE_INT_RGB);    
            int height_i = 0;    
            for (int i = 0; i < images.length; i++) {    
                ImageNew.setRGB(0, height_i, dst_width, images[i].getHeight(),  imageArrays[i], 0, dst_width);    
                height_i += images[i].getHeight();    
            }    
            File outFile = new File(dst_pic);    
            ImageIO.write(ImageNew, type, outFile);// 写图片     
        } catch (Exception e) {    
            e.printStackTrace();    
            return false;    
        }    
        return true;    
    }    
      
    /** 
     * 合并图片(按指定初始x、y坐标将附加图片贴到底图之上) 
     * @param negativeImagePath 背景图片路径 
     * @param additionImagePath 附加图片路径 
     * @param x 附加图片的起始点x坐标 
     * @param y  附加图片的起始点y坐标 
     * @param toPath 图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImage(String negativeImagePath,String additionImagePath,int x,int y,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,x,y,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /**  
     * 将一组图片一次性附加合并到底图上 
     * @param negativeImagePath     源图像（底图）路径 
     * @param additionImageList 附加图像信息列表 
     * @param imageFormat   图像写入格式 
     * @param toPath    图像写入路径 
     * @throws IOException 
     */  
    public void mergeImageList(String negativeImagePath,List additionImageList,String imageFormat, String toPath) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            BufferedImage image=ImageIO.read(is);  
            //Graphics g=image.getGraphics();  
            Graphics2D g = image.createGraphics();;  
            BufferedImage image2 = null;  
            if(additionImageList != null){  
                for(int i=0;i<additionImageList.size();i++){  
                    //解析附加图片信息：x坐标、 y坐标、 additionImagePath附加图片路径  
                    //图片信息存储在一个数组中  
                    String[] additionImageInfo = (String[]) additionImageList.get(i);  
                    int x = Integer.parseInt(additionImageInfo[0]);  
                    int y = Integer.parseInt(additionImageInfo[1]);  
                    String additionImagePath = additionImageInfo[2];  
                    //读取文件输入流，并合并图片  
                    is2 = new FileInputStream(additionImagePath);  
                    //System.out.println(x+"  :  "+y+"  :  "+additionImagePath);  
                    image2 = ImageIO.read(is2);  
                    g.drawImage(image2,x,y,null);  
                }  
            }  
            os = new FileOutputStream(toPath);  
            ImageIO.write(image,  imageFormat,  os);//写图片  
            //JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            //enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的左上角 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageTopleftcorner(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,0,0,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的右上角 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageToprightcorner(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()-image2.getWidth(),0,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的左下角 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageLeftbottom(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,0,image.getHeight()-image2.getHeight(),null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的左下角 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageRightbottom(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()-image2.getWidth(),image.getHeight()-image2.getHeight(),null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的正中央 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageCenter(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()/2-image2.getWidth()/2,image.getHeight()/2-image2.getHeight()/2,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的上边中央 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageTopcenter(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()/2-image2.getWidth()/2,0,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的下边中央 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageBottomcenter(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()/2-image2.getWidth()/2,image.getHeight()-image2.getHeight(),null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的左边中央 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageLeftcenter(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,0,image.getHeight()/2-image2.getHeight()/2,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 将附加图片合并到底图的右边中央 
     * @param negativeImagePath 底图路径 
     * @param additionImagePath 附加图片路径 
     * @param toPath    合成图片写入路径 
     * @throws IOException 
     */  
    public void mergeBothImageRightcenter(String negativeImagePath,String additionImagePath,String toPath ) throws IOException{  
        InputStream is= null;  
        InputStream is2= null;  
        OutputStream os = null;  
        try{  
            is=new FileInputStream(negativeImagePath);  
            is2=new FileInputStream(additionImagePath);  
            BufferedImage image=ImageIO.read(is);  
            BufferedImage image2=ImageIO.read(is2);  
            Graphics g=image.getGraphics();  
            g.drawImage(image2,image.getWidth()-image2.getWidth(),image.getHeight()/2-image2.getHeight()/2,null);  
            os = new FileOutputStream(toPath);  
            JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);  
            enc.encode(image);  
        }catch(Exception e){  
            e.printStackTrace();  
        }finally{  
            if(os != null){  
                os.close();  
            }  
            if(is2 != null){  
                is2.close();  
            }  
            if(is != null){  
                is.close();  
            }  
        }  
    }  
      
    /** 
     * 图片灰化操作 
     * @param srcImage 读取图片路径 
     * @param toPath    写入灰化后的图片路径 
     * @param imageFormat 图片写入格式 
     */   
    public void grayImage(String srcImage,String toPath,String imageFormat){  
        try{  
            BufferedImage src = ImageIO.read(new File(srcImage));  
            ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);  
            ColorConvertOp op = new ColorConvertOp(cs, null);  
            src = op.filter(src, null);  
            ImageIO.write(src, imageFormat, new File(toPath));  
        }catch(Exception e){  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 在源图片上设置水印文字 
     * @param srcImagePath  源图片路径 
     * @param alpha 透明度（0<alpha<1） 
     * @param font  字体（例如：宋体） 
     * @param fontStyle     字体格式(例如：普通样式--Font.PLAIN、粗体--Font.BOLD ) 
     * @param fontSize  字体大小 
     * @param color 字体颜色(例如：黑色--Color.BLACK) 
     * @param inputWords        输入显示在图片上的文字 
     * @param x     文字显示起始的x坐标 
     * @param y     文字显示起始的y坐标 
     * @param imageFormat   写入图片格式（png/jpg等） 
     * @param toPath    写入图片路径 
     * @throws IOException  
     */  
    public void alphaWords2Image(String srcImagePath,float alpha,  
            String font,int fontStyle,int fontSize,Color color,  
            String inputWords,int x,int y,String imageFormat,String toPath) throws IOException{  
        FileOutputStream fos=null;  
        try {  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //创建java2D对象  
            Graphics2D g2d=image.createGraphics();  
            //用源图像填充背景  
            g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null, null);  
            //设置透明度  
            AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);  
            g2d.setComposite(ac);  
            //设置文字字体名称、样式、大小  
            g2d.setFont(new Font(font, fontStyle, fontSize));  
            g2d.setColor(color);//设置字体颜色  
            g2d.drawString(inputWords, x, y); //输入水印文字及其起始x、y坐标  
            g2d.dispose();  
            fos=new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);  
        } catch (Exception e) {  
           e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 在源图像上设置图片水印   
     *  ---- 当alpha==1时文字不透明（和在图片上直接输入文字效果一样） 
     * @param srcImagePath  源图片路径 
     * @param appendImagePath   水印图片路径 
     * @param alpha 透明度 
     * @param x     水印图片的起始x坐标 
     * @param y     水印图片的起始y坐标 
     * @param width 水印图片的宽度 
     * @param height        水印图片的高度 
     * @param imageFormat   图像写入图片格式 
     * @param toPath    图像写入路径 
     * @throws IOException  
     */  
    public void alphaImage2Image(String srcImagePath,String appendImagePath,  
            float alpha,int x,int y,int width,int height,  
            String imageFormat,String toPath) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //创建java2D对象  
            Graphics2D g2d=image.createGraphics();  
            //用源图像填充背景  
            g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null, null);  
            //设置透明度  
            AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);  
            g2d.setComposite(ac);  
            //设置水印图片的起始x/y坐标、宽度、高度  
            BufferedImage appendImage = ImageIO.read(new File(appendImagePath));  
            g2d.drawImage(appendImage, x, y, width, height, null, null);  
            g2d.dispose();  
            fos=new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);  
        } catch (Exception e) {  
           e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 画单点 ---- 实际上是画一个填充颜色的圆 
     * ---- 以指定点坐标为中心画一个小半径的圆形，并填充其颜色来充当点 
     * @param srcImagePath   源图片颜色 
     * @param x     点的x坐标 
     * @param y     点的y坐标 
     * @param width 填充的宽度 
     * @param height    填充的高度 
     * @param ovalColor 填充颜色 
     * @param imageFormat   写入图片格式 
     * @param toPath    写入路径 
     * @throws IOException 
     */  
    public void drawPoint(String srcImagePath,int x,int y,int width,int height,Color ovalColor,String imageFormat,String toPath) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取源图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制连接线  
            Graphics2D g2d = image.createGraphics();  
            g2d.setColor(ovalColor);  
            //填充一个椭圆形  
            g2d.fillOval(x, y, width, height);  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 画一组（多个）点---- 实际上是画一组（多个）填充颜色的圆 
     * ---- 以指定点坐标为中心画一个小半径的圆形，并填充其颜色来充当点 
     * @param srcImagePath  原图片路径 
     * @param pointList 点列表 
     * @param width 宽度 
     * @param height        高度 
     * @param ovalColor 填充颜色 
     * @param imageFormat   写入图片颜色 
     * @param toPath    写入路径 
     * @throws IOException 
     */  
    public void drawPoints(String srcImagePath,List pointList,int width,int height,Color ovalColor,String imageFormat,String toPath) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取源图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制连接线  
            Graphics2D g2d = image.createGraphics();  
            g2d.setColor(ovalColor);  
            //填充一个椭圆形  
            if(pointList != null){  
                for(int i=0;i<pointList.size();i++){  
                    Point point = (Point)pointList.get(i);  
                    int x = (int) point.getX();  
                    int y = (int) point.getY();  
                    g2d.fillOval(x, y, width, height);  
                }  
            }  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 画线段 
     * @param srcImagePath  源图片路径 
     * @param x1    第一个点x坐标 
     * @param y1    第一个点y坐标 
     * @param x2    第二个点x坐标 
     * @param y2    第二个点y坐标 
     * @param lineColor 线条颜色 
     * @param toPath    图像写入路径 
     * @param imageFormat   图像写入格式 
     * @throws IOException   
     */  
    public void drawLine(String srcImagePath,int x1,int y1,int x2,int y2, Color lineColor,String toPath,String imageFormat) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取源图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制连接线  
            Graphics2D g2d = image.createGraphics();  
            g2d.setColor(lineColor);  
            g2d.drawLine( x1, y1, x2, y2);  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 画折线 / 线段 
     * ---- 2个点即画线段，多个点画折线 
     * @param srcImagePath  源图片路径 
     * @param xPoints   x坐标数组 
     * @param yPoints   y坐标数组 
     * @param nPoints   点的数量 
     * @param lineColor 线条颜色 
     * @param toPath    图像写入路径 
     * @param imageFormat   图片写入格式 
     * @throws IOException   
     */  
    public void drawPolyline(String srcImagePath,int[] xPoints, int[] yPoints, int nPoints,Color lineColor,String toPath,String imageFormat) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取源图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制连接线  
            Graphics2D g2d = image.createGraphics();  
            //设置线条颜色  
            g2d.setColor(lineColor);  
            g2d.drawPolyline(xPoints, yPoints, nPoints);  
            //图像写出路径  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
    /** 
     * 绘制折线，并突出显示转折点 
     * @param srcImagePath  源图片路径 
     * @param xPoints   x坐标数组 
     * @param yPoints   y坐标数组 
     * @param nPoints   点的数量 
     * @param lineColor 连线颜色 
     * @param width 点的宽度 
     * @param height        点的高度 
     * @param ovalColor 点的填充颜色 
     * @param toPath    图像写入路径 
     * @param imageFormat   图像写入格式 
     * @throws IOException 
     */  
    public void drawPolylineShowPoints(String srcImagePath,int[] xPoints, int[] yPoints, int nPoints,Color lineColor,int width,int height,Color ovalColor,String toPath,String imageFormat) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取源图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制连接线  
            Graphics2D g2d = image.createGraphics();  
            //设置线条颜色  
            g2d.setColor(lineColor);  
            //画线条  
            g2d.drawPolyline(xPoints, yPoints, nPoints);  
            //设置圆点颜色  
            g2d.setColor(ovalColor);  
            //画圆点  
            if(xPoints != null){  
                for(int i=0;i<xPoints.length;i++){  
                    int x = xPoints[i];  
                    int y = yPoints[i];  
                    g2d.fillOval(x, y, width, height);  
                }  
            }  
            //图像写出路径  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }  
        }  
    }  
      
      
    /**  
     * 绘制一个由 x 和 y 坐标数组定义的闭合多边形 
     * @param srcImagePath 源图片路径 
     * @param xPoints   x坐标数组 
     * @param yPoints   y坐标数组 
     * @param nPoints   坐标点的个数 
     * @param polygonColor  线条颜色 
     * @param imageFormat   图像写入格式 
     * @param toPath    图像写入路径 
     * @throws IOException  
     */  
    public void drawPolygon(String srcImagePath,int[] xPoints,int[] yPoints,int nPoints,Color polygonColor,String imageFormat,String toPath) throws IOException {  
        FileOutputStream fos = null;  
        try {  
            //获取图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制闭合多边形  
            Graphics2D g2d = image.createGraphics();  
            g2d.setColor(polygonColor);  
            g2d.drawPolygon(xPoints, yPoints, nPoints);  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
            g2d.dispose();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }   
        }  
    }  
      
    /** 
     * 绘制并填充多边形 
     * @param srcImagePath  源图像路径 
     * @param xPoints   x坐标数组 
     * @param yPoints   y坐标数组 
     * @param nPoints   坐标点个数 
     * @param polygonColor  多边形填充颜色 
     * @param alpha 多边形部分透明度 
     * @param imageFormat   写入图形格式 
     * @param toPath    写入图形路径 
     * @throws IOException 
     */  
    public void drawAndAlphaPolygon(String srcImagePath,int[] xPoints,int[] yPoints,int nPoints,Color polygonColor,float alpha,String imageFormat,String toPath) throws IOException{  
        FileOutputStream fos = null;  
        try {  
            //获取图片  
            BufferedImage image = ImageIO.read(new File(srcImagePath));  
            //根据xy点坐标绘制闭合多边形  
            Graphics2D g2d = image.createGraphics();  
            g2d.setColor(polygonColor);  
            //设置透明度  
            AlphaComposite ac = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha);  
            g2d.setComposite(ac);  
            g2d.fillPolygon(xPoints, yPoints, nPoints);  
            fos = new FileOutputStream(toPath);  
            ImageIO.write(image, imageFormat, fos);   
            g2d.dispose();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }finally{  
            if(fos!=null){  
                fos.close();  
            }   
        }  
    }  
      
      
    public static void main(String[] args)throws Exception{  
    	ImageUtil imageObj = new ImageUtil();  
    }
} 
